#include "linked_list_common.h"
#include "student_common.h"
#include <iostream>
using namespace std;

// 构造函数
linked_list::linked_list() : head(nullptr), tail(nullptr), size(0) {}

// 析构函数
linked_list::~linked_list()
{
    clear(this);
}
// 节点结构体
typedef struct linked_list::node
{
    void *data;        // 节点数据
    struct node *prev; // 前驱指针
    struct node *next; // 后继指针
} node;

// 初始化链表（将其改为成员函数）
void linked_list::init()
{
    // 头节点为空
    head = nullptr;
    // 尾节点为空
    tail = nullptr;
    // 长度为0
    size = 0;
}
// 初始化节点
node *create_node(void *data)
{
    node *new_node = new node;
    if (new_node == nullptr)
    {
        cout << "内存分配失败" << endl;
        exit(EXIT_FAILURE); // 异常退出
    }
    new_node->data = data;
    new_node->next = nullptr;
    new_node->prev = nullptr;
    return new_node;
}
// 头插
void linked_list::insert_head(linked_list *list, void *data)
{
    // 创建新节点
    node *new_code = create_node(data);
    // 是否为空链表
    if (head == nullptr)
    {
        // 为空的话，这个数据就是头尾节点
        head = new_code;
        tail = new_code;
    }
    else
    { // 若不是空链表，则将data插入到头部
        // 即新节点的后驱节点等于当前的链表的头节点
        new_code->next = list->head;
        list->head->prev = new_code; // 当前链表的头节点的前驱节点等于新节点
        list->head = new_code;       // 更新头节点为new_code
    }
    // 链表数据+1
    list->size++;
}
// 尾插
void linked_list::insert_tail(linked_list *list, void *data)
{
    // 创建新节点
    node *new_code = create_node(data);
    // 是否为空链表
    if (list->tail == nullptr)
    {
        // 为空的话，这个数据就是头尾节点
        list->head = new_code;
        list->tail = new_code;
    }
    else
    { // 若不是空链表，则将data插入到尾部
        // 即新节点的前驱节点等于当前的链表的尾节点
        new_code->prev = list->tail;
        list->tail->next = new_code; // 当前链表的尾节点的后继节点等于新节点
        list->tail = new_code;       // 更新尾节点为new_code
    }
    // 链表数据+1
    list->size++;
}
// 中间插（指定位置）
void linked_list::insert_middle(linked_list *list, void *data, int position)
{
    if (position < 0 || position > list->size)
    {
        cout << "位置不合法" << endl;
        return;
    }
    if (position == 0)
    {
        insert_head(list, data);
        return;
    }
    if (position == list->size)
    {
        insert_tail(list, data);
        return;
    }

    // 创建新节点
    node *new_code = create_node(data);
    node *current = list->head;

    // 找到插入位置的前一个节点
    for (int i = 0; i < position - 1; i++)
    {
        current = current->next;
    }

    // 插入新节点
    new_code->next = current->next; // 新节点的后继节点等于当前节点的后继节点
    new_code->prev = current;       // 新节点的前驱节点等于当前节点
    current->next->prev = new_code; // 当前节点的后继节点的前驱节点等于新节点
    current->next = new_code;       // 当前节点的后继节点等于新节点

    // 链表数据+1
    list->size++;
}

// 头删
void linked_list::delete_head(linked_list *list)
{
    if (list->head == nullptr)
    {
        cout << "链表为空，无法删除头节点" << endl;
        return;
    }

    node *temp = list->head;       // 临时保存头节点
    list->head = list->head->next; // 更新头节点为下一个节点

    if (list->head != nullptr) // 如果新的头节点不为空
    {
        list->head->prev = nullptr; // 新的头节点的前驱指针设为nullptr
    }
    else // 如果新的头节点为空，说明链表现在为空
    {
        list->tail = nullptr; // 尾节点也设为nullptr
    }

    delete temp;  // 删除原头节点
    list->size--; // 链表大小减1
}

// 尾删
void linked_list::delete_tail(linked_list *list)
{
    if (list->tail == nullptr)
    {
        cout << "链表为空，无法删除尾节点" << endl;
        return;
    }

    node *temp = list->tail;       // 临时保存尾节点
    list->tail = list->tail->prev; // 更新尾节点为前一个节点

    if (list->tail != nullptr) // 如果新的尾节点不为空
    {
        list->tail->next = nullptr; // 新的尾节点的后继指针设为nullptr
    }
    else // 如果新的尾节点为空，说明链表现在为空
    {
        list->head = nullptr; // 头节点也设为nullptr
    }

    delete temp;  // 删除原尾节点
    list->size--; // 链表大小减1
}
// 中间删（指定位置）
void linked_list::delete_middle(linked_list *list, int position)
{
    if (position < 0 || position >= list->size)
    {
        cout << "位置不合法" << endl;
        return;
    }
    if (position == 0)
    {
        delete_head(list);
        return;
    }
    if (position == list->size - 1)
    {
        delete_tail(list);
        return;
    }

    node *current = list->head;

    // 找到要删除的节点
    for (int i = 0; i < position; i++)
    {
        current = current->next;
    }

    // 更新前驱和后继节点的指针
    current->prev->next = current->next; // 前驱节点的后继指针指向当前节点的后继节点
    current->next->prev = current->prev; // 后继节点的前驱指针指向当前节点的前驱节点

    delete current; // 删除当前节点
    list->size--;   // 链表大小减1
}
// 修改链表数据
void linked_list::update_middle(linked_list *list, void *data, int position)
{
    if (position < 0 || position >= list->size)
    {
        cout << "位置不合法" << endl;
        return;
    }

    node *current = list->head;

    // 找到要修改的节点
    for (int i = 0; i < position; i++)
    {
        current = current->next;
    }

    // 修改数据
    current->data = data;
}
// 链表大小

// 打印链表(正序)
void linked_list::print_forward(linked_list *list)
{
    node *current = list->head;
    while (current != nullptr)
    {
        student *stu = static_cast<student *>(current->data);
        cout << stu->get_student_id() << ", "
             << stu->get_student_age() << ", "
             << stu->get_student_name() << ", "
             << stu->get_student_address() << endl;
        current = current->next;
    }
}
// 打印链表（倒序）
void linked_list::print_backward(linked_list *list)
{
    node *current = list->tail;
    while (current != nullptr)
    {
        student *stu = static_cast<student *>(current->data);
        cout << stu->get_student_id() << ", "
             << stu->get_student_age() << ", "
             << stu->get_student_name() << ", "
             << stu->get_student_address() << endl;
        current = current->prev;
    }
}
// 清除链表
void linked_list::clear(linked_list *list)
{
    while (list->head != nullptr)
    {
        delete_head(list);
    }
}
// 获取链表大小
int linked_list::get_size(linked_list *list)
{
    return list->size;
}